COMMENT ⊗   VALID 00005 PAGES
C REC  PAGE   DESCRIPTION
C00001 00001
C00002 00002	constraints
C00003 00003
C00006 00004	Culler-Fried
C00012 00005	in lisp, need:
C00014 ENDMK
C⊗;
constraints

visicalc

thinglab

logo linked turtles

smalltalk examples

turtle geo

sophie+gls

culler

education
    logo
    smalltalk
    lisp
    books
    summer school

refs.
mindstorms
world challenge
turtle geo
culler stuff

Useable Systems

The key to the wide-spread use of computing resources is the development
of  effective user interfaces. A successful example of this phenomenon
is Visicalc. This micro-based software tool

***  describe it ***

Visicalc is an exceptionally simple application of a computing technique
called "constraints". We exhibit several examples of constraint 
notions and show that there is a rich class of applications that are
potential products.  We propose to exploit that initial market immediately while
developing general tools  to assure the speedy implemenation of more
advanced applications as hardware becomes available.


Computing tools have a reputation for being formidable.

Cost

Size

Obscure communication

Mindless

No common sense

No sense of inconsistency

Irresponsible
--------------------------------------------
How to address these problems.

Cost
 micro technology

Size
 vlsi

Obscure communication
 speech/natural language communication
 graphics: visual presentation
 flexible declarative  languages

Irresponsible systems:  the difficulty!

No common sense
 deduction

No sense of inconsistency
 sense of truth

--------------------------------------------
Constraints: The kernel notions 

objects are interrelated: a change of one can affect change in another
examples: 
   visicalc
   thinglab
   gls circuit
   dpl* design rules
   turtles/physics

systems must be responsible: an inconsistency must be detectable
examples:

systems must be directable: an object must be retractable
examples:


what can be done now 
  visicalc+
  sophie+gls
  dpl
  culler+

what can be expected

 system building tools

  constraint languages
 
  expert systems


what is required now
  machines

  people

  facilities
Culler-Fried

This is one of the first  truly interactive  graphics systems.
This system is based on the manipulation of finite function-segments.
The function segments are approximated by  a finite number of points
in a user-specified range, and are represented as a vector of "ordinate" values.
For example, the function y=x [-1,1] is represented as sequence
of equally-spaced real numbers in the range [-1, 1], the density of which
is implementation dependent, but typically is several hundred samples.

One can build up such objects using primitive operations,
 and function composition.


For example, in a typical Culler-Freid system one has the following
function keys:

id	to  construct the identity function y=x [-1,1]

*	to  invoke point-wise multiplication of functional components

2	to  construct the constant function y=2.

↑	to  invoke the exponentation function g(x)↑f(x)

Thus, the keystroke sequence: id*2↑2   will construct the parabolic
segment 2x↑2 over the range [-1,1] (2*id↑2 would work equally well).

One may view this results by  pressing the "display" key. This key will
plot the computed values against another such vector. If that vector is the
identity vector, we will see the  function y=2*x↑2

Of course, one may vary the  vector which represents the "abcissa" values,
opening the possibility to plot parametric functions: y=sin(t) versus
x=cons(t) will give us a circular plot.

***example of nice parametric plot.

With these examples, we have the basic ingredients of the system:
data structures as finite vectors representing ordinates of functions,
operations to transform the components of the vectors, an operation to display
the results of a computation. These elements are reminiscent of 
those found on a hand calculator. Indeed, the system can be used as such;
however its generality extends past this simple behavior. A Culler system
contains all of the components typically found in a computing system including
the ability to build and name new operations to be invoked later.
This added functionality allows us to define a sequence of keystrokes --a program--
and associate it with a specified key.  Thus λ((v) v↑2) and sqr = λ((v) v↑2),
and the composition sqr(sqr) denotes λ((v) v↑4).

With this collection of operations, we have defined a machine that performs
simple arithmetic operations on functions. We can effectively extend the power
of this subset by including approximation to functions not explicitly
definable in "close form". For example, we might define a segment of the
sine function as:

sin(t) = x/6 + kkl****

Though interesting and non-trivial
applications result from this subset, such systems come into their own when
they are extended to  include operations for differentiation and integration
of functions segments.

The heart of the calculus operations are two primitives --finite differences,
and running sums.

***example *****

Given these primitives, we have opened to door to real analysis, in
particular, the on-line interactive solution to differential and integral
equations.


-----
extensions:
1. many dimensions
	graphing problems: hidden line elimination, and rotations

2. color
	not problematic

3. symbolic capability --algebraic ops.
  	explore: simple lisp analysis to macsyma  interaction
-----
applications


in lisp, need:

α and β

id 

load

store

should have push and pop

display

read eval print => readch (maybe more keys)
		   eval  
		   display α versus β

id*2↑2

id => load β to toplev

* => loop(*)

↑ => loop(*)

2 => load WS

 loop(OP): readch ? rator => to toplev1
		    rand  => get (in WS); OP it to β; go loop

 toplev:   readch 
 toplev1:  ? rator => β empty? => error
		  	 o.w.  => do it to β
	     rand =>  get (in WS); move to β; go toplev


need paren-parser
a OP b OP1 c   as: (a OP b) OP1 c  

versus  a OP b OP1 c   as: a OP (b OP1 c)

push a
push op
push b
tos 
push op1
push c
tos 

push a
push op
push b
push op1
push c
tos 
tos